home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / mint / filesy~1 / mfs610s.zoo / minixfs / minixfs.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-11  |  14.7 KB  |  400 lines
  1. #ifndef minixfs_h
  2. #define minixfs_h
  3.  
  4. #include <sys/types.h>
  5. #include <string.h>
  6. #include <ctype.h>
  7.  
  8. #include "atarierr.h"
  9. #include "filesys.h"
  10.  
  11. #include "kernel.h"
  12.  
  13. #include "config.h"
  14.  
  15. #define DOM_TOS 0
  16. #define DOM_MINT 1
  17. #define NUM_DRIVES 32
  18.  
  19. #ifndef NULL
  20. #define NULL 0L
  21. #endif
  22.  
  23. /* Useful macro , is non zero only if 'x' is not a power of two */
  24.  
  25. #define NPOW2(x) ( ( (x) & (x-1) )!=0)
  26.  
  27. /* Dates smaller than 1st Jan 1980 confuse dostime _corr avoids them */
  28.  
  29. #define _corr(t) ( (t > 315532800L) ? t : 315532800L)
  30.  
  31. #define SIZEOF sizeof
  32.  
  33. /* General types we will use */
  34. typedef unsigned short unshort;
  35. typedef unsigned short ushort;
  36. typedef unsigned char unchar;
  37.  
  38. /* Constants for fscntl */
  39.  
  40. #define MFS_BASE    0x100
  41. #define MFS_VERIFY    (MFS_BASE)    /* Return minixfs magic number */
  42. #define MFS_SYNC    (MFS_BASE|0x01)    /* Sync the filesystem */
  43. #define MFS_CINVALID    (MFS_BASE|0x02)    /* Invalidate cache entries */
  44. #define MFS_FINVALID    (MFS_BASE|0x03)    /* Invalidate Fileptrs */
  45. #define MFS_INFO    (MFS_BASE|0x04)    /* Get info about filesystem */
  46. #define MFS_USAGE    (MFS_BASE|0x05)    /* Get block allocation of a file */
  47. #define MFS_IMODE    (MFS_BASE|0x06)    /* Change all bits in an inode mode */
  48. #define MFS_GTRANS    (MFS_BASE|0x07) /* Get filename translation mode */ 
  49. #define MFS_STRANS    (MFS_BASE|0x08) /* Set filename translation mode */
  50. #define MFS_PHYS    (MFS_BASE|0x09) /* Get physical partition info */
  51. #define MFS_IADDR    (MFS_BASE|0x0a) /* Get start address of minixfs */
  52. #define MFS_UPDATE    (MFS_BASE|0x0b) /* Update daemon controls */
  53. #define MFS_MOUNT    (MFS_BASE|0x0c) /* Mount a filesystem */
  54. #define MFS_UMOUNT    (MFS_BASE|0x0d) /* Umount a filesystem */
  55. #define MFS_LOPEN    (MFS_BASE|0x0e) /* Get list of open files on device */
  56. #define MFS_MKNOD    (MFS_BASE|0x0f) /* Make special file */
  57.  
  58. #define MFS_MAGIC    0x18970431    /* Magic number from MFS_VERIFY */
  59.  
  60. /* Filename translation modes */
  61.  
  62. #define SRCH_TOS    0x01        /* search with tosify , tos domain  */
  63. #define SRCH_MNT    0x02        /* search with tosify , mint domain */
  64. #define DIR_TOS        0x04        /* dir compat tosify  , tos domain  */
  65. #define DIR_MNT        0x08        /* dir compat tosify  , mint domain */
  66. #define LWR_TOS        0x10        /* lower case creat   , tos domain  */
  67. #define LWR_MNT        0x20        /* lower case creat   , mint domain */
  68. #define AEXEC_TOS    0x40        /* auto 'x' ,   tos domain.   */
  69. #define AEXEC_MNT    0x80        /* auto 'x' ,    mint domain. */
  70.  
  71. #ifndef FUTIME
  72. #define FUTIME        (('F'<< 8) | 3)
  73. #endif
  74.  
  75. #ifndef FTRUNCATE
  76. #define FTRUNCATE    (('F'<< 8) | 4)
  77. #endif
  78.  
  79. typedef struct {
  80. long total_inodes,total_zones;
  81. long free_inodes,free_zones;
  82. int version;            /* Filesystem version 1=V1 2=V2 */
  83. int increment;            /* Directory increment */
  84. long res1,res2,res3,res4;    /* Reserved for future use */
  85. } mfs_info;
  86.  
  87. /* Mounting structure */
  88. typedef struct {
  89. unsigned dev;        /* Bios device number */
  90. long flags;        /* Mounting flags */
  91. long reserved[4];    /* Reserved for future use */
  92. } mfs_mount;
  93.  
  94.  
  95. /* Structure for returning list of open inodes on device */
  96.  
  97. typedef struct {
  98. long limit;        /* Number of elements in flist */
  99. unsigned flist[1];    /* Inode list */
  100. } openf_list;
  101.  
  102. #define MNT_CHANGE    0x1    /* Ignore disk change */
  103.  
  104. #ifdef NDEBUG
  105. #define assert(expression)
  106. #else
  107. # ifdef __STDC__
  108. #define assert(expression) \
  109.     ((expression) ? 0 : FATAL("assert(`%s') failed at line %ld of %s.", \
  110.         #expression, (long)__LINE__, __FILE__))
  111. # else
  112. #define assert(expression) if(expression) FATAL("assert(%s) failed", \
  113.         "expression")
  114. # endif
  115. #endif
  116.  
  117.  
  118.  
  119. /* Macro to determine maximum filename length for a given increment */
  120.  
  121. #define MMAX_FNAME(x) ( ( (x)<<4 ) -2)
  122.  
  123. /* Absolute maximum filename length */
  124.  
  125. #define MNAME_MAX MMAX_FNAME(MAX_INCREMENT)
  126.  
  127. #define BLOCK_SIZE    1024    /* # bytes in a disk block */
  128. #define L_BS        10    /* log 2 bytes/block */
  129.  
  130. #define MAJOR             8    /* major device = (dev>>MAJOR) & 0377 */
  131. #define MINOR             0    /* minor device = (dev>>MINOR) & 0377 */
  132. #define NOLAST    (unshort *) 0    /* We dont want parent directory of a file */
  133.  
  134. /* Flag bits for i_mode in the inode. */
  135.  
  136.  
  137. #define I_OLDLINK    0160000 /* old symbolic link mode */
  138.  
  139. #define I_SYMLINK    0120000    /* symbolic link (Linux compatible) */
  140. #define I_TYPE        0170000    /* this field gives inode type */
  141. #define I_REGULAR    0100000    /* regular file, not dir or special */
  142. #define I_BLOCK_SPECIAL 0060000    /* block special file */
  143. #define I_DIRECTORY    0040000    /* file is a directory */
  144. #define I_CHAR_SPECIAL    0020000    /* character special file */
  145. #define I_NAMED_PIPE    0010000 /* named pipe (FIFO) */
  146. #define I_SET_UID_BIT    0004000    /* set effective uid on exec */
  147. #define I_SET_GID_BIT    0002000    /* set effective gid on exec */
  148. #define I_STICKY    0001000 /* sticky bit */
  149. #define ALL_MODES    0007777    /* all bits for user, group and others */
  150. #define RWX_MODES    0000777    /* mode bits for RWX only */
  151. #define R_BIT        0000004    /* Rwx protection bit */
  152. #define W_BIT        0000002    /* rWx protection bit */
  153. #define X_BIT        0000001    /* rwX protection bit */
  154. #define I_NOT_ALLOC    0000000    /* this inode is free */
  155.  
  156. /* Useful macros */
  157. #define IS_DIR(m)    ((m.i_mode & I_TYPE)==I_DIRECTORY)
  158. #define IS_REG(m)    ((m.i_mode & I_TYPE)==I_REGULAR)
  159. #define IS_SYM(m)    ((m.i_mode & I_TYPE)==I_SYMLINK)
  160.  
  161. #define IM_SPEC(m)    (((m & I_TYPE)==I_CHAR_SPECIAL) \
  162.                 || ((m & I_TYPE)==I_BLOCK_SPECIAL))
  163.  
  164. /* Flag bits for cookie 'aux' field */
  165.  
  166. #define AUX_DEV     0x1f    /* Mask for bios device */
  167. #define AUX_DRV     0x20    /* First 5 bits are bios dev mask */
  168. #define AUX_DEL     0x40    /* file marked for deletion */
  169. #define AUX_SYNC 0x80    /* l_sync() on next write */
  170.  
  171. /* Tables sizes */
  172. #define NR_ZONE_NUMS       9    /* # zone numbers in an inode */
  173. #define NR_ZONE_NUMS2      10    /* #zone numbers in v2 inode */
  174.  
  175. /* Miscellaneous constants */
  176. #define SUPER_MAGIC   0x137F    /* magic number contained in super-block */
  177. #define SUPER_V1_30   0x138f    /* magic number for Linux+V1+30chars */
  178. #define SUPER_V2      0x2468    /* v2 magic number */
  179.  
  180. #define FIND        0    /* tells search_dir to search for file */
  181. #define ADD        1    /* tells search_dir to add a dir entry */
  182. #define KILL        2    /* tells search_dir to kill entry     */
  183. #define POS        3    /* tells search_dir to find position   */
  184.  
  185. #define INVALID        0    /* Cache entry is garbage */
  186. #define CLEAN           1    /* Cache entry same as disk */
  187. #define DIRTY           2    /* Cache entry is more recent than disk */
  188. #define LOCKED           4    /* do not overwrite entry */
  189.  
  190. #define NOLOCK           3    /* Bits not connected with locks */
  191.  
  192. #define BOOT_BLOCK  0        /* block number of boot block */
  193. #define SUPER_BLOCK 1        /* block number of super block */
  194. #define ROOT_INODE  (unshort)1    /* inode number for root directory */
  195.  
  196.  
  197. /* Derived sizes */
  198. #define ZONE_NUM_SIZE     (SIZEOF(unshort))         /* # bytes in zone nr  */
  199. #define NR_DZONE_NUM     (NR_ZONE_NUMS-2)         /* # zones in inode    */
  200. #define DIR_ENTRY_SIZE     (SIZEOF(dir_struct))         /* # bytes/dir entry   */
  201. #define L_DIR_SIZE     4                 /* log2 bytes/dir entry */    
  202. #define INODES_PER_BLOCK (BLOCK_SIZE/INODE_SIZE)     /* # inodes/disk blk   */
  203. #define L_IPB         5                 /* log2 inodes/blk */
  204. #define INODE_SIZE     (SIZEOF(d_inode1))         /* bytes in disk inode */
  205. #define NR_DIR_ENTRIES     (BLOCK_SIZE/DIR_ENTRY_SIZE) /* # dir entries/block */
  206. #define NR_INDIRECTS     (BLOCK_SIZE/ZONE_NUM_SIZE)  /* # zones/indir block */
  207. #define LNR_IND         9                 /* log 2 NR_INDIRECTS */
  208. #define NR_DBL         (NR_DZONE_NUM+NR_INDIRECTS) /* 1st zone in dbl ind */
  209. #define INTS_PER_BLOCK     (BLOCK_SIZE/SIZEOF(int))    /* # integers/block    */
  210. #define SUPER_SIZE     (SIZEOF(struct super_block)) /* super_block size    */
  211. #define PIPE_SIZE     (NR_DZONE_NUM*BLOCK_SIZE)   /* pipe size in bytes  */
  212. #define MAX_ZONES (NR_DZONE_NUM+(NR_INDIRECTS+1l)*NR_INDIRECTS)
  213.  
  214. #define NR_ZONE_NUMS2    10
  215. #define NR_DZONE_NUM2    (NR_ZONE_NUMS2-3)
  216. #define ZONE_NUM_SIZE2    (SIZEOF(long))
  217. #define INODES_PER_BLOCK2 (BLOCK_SIZE/INODE_SIZE2)
  218. #define L_IPB2        4
  219. #define INODE_SIZE2    (SIZEOF(d_inode))
  220. #define NR_INDIRECTS2    (BLOCK_SIZE/ZONE_NUM_SIZE2)
  221. #define LNR_IND2    8
  222. #define NR_DBL2        (NR_DZONE_NUM2+NR_INDIRECTS2)
  223. #define MAX_ZONES2 (NR_DZONE_NUMS2+(NR_INDIRECTS2+1l)*NR_INDIRECTS2)
  224.  
  225. #ifndef SEEK_SET
  226. /* lseek() origins */
  227. #define    SEEK_SET    0        /* from beginning of file */
  228. #define    SEEK_CUR    1        /* from current location */
  229. #define    SEEK_END    2        /* from end of file */
  230. #endif
  231.  
  232.  
  233. #ifndef min
  234. #define min(a,b) ((a)>(b) ? (b) : (a))
  235. #endif
  236.  
  237. typedef struct    {
  238.   unshort s_ninodes;        /* # usable inodes on the minor device */
  239.   unshort s_nzones;        /* total device size, including bit maps etc */
  240.   unshort s_imap_blks;        /* # of blocks used by inode bit map */
  241.   unshort s_zmap_blks;        /* # of blocks used by zone bit map */
  242.   unshort s_firstdatazn;    /* number of first data zone */
  243.   short int s_log_zsize;    /* log2 of blocks/zone */
  244.   long s_max_size;        /* maximum file size on this device */
  245.   short s_magic;        /* magic number to recognize super-blocks */
  246.   short pad;            /* padding */
  247.   long s_zones;            /* long version of s_nzones for v2 */
  248. } super_block;
  249.  
  250. /* super_info contains information about each Minix filesystem */
  251.  
  252. typedef struct  __sinf {
  253.     super_block sblk;    /* Actual super block */
  254.     int dev;        /* Device this belongs to */
  255.     long serialno;        /* Serial number of disk (ignored for now)*/
  256.     long ioff;        /* Offset to inode 1 */
  257.     ushort *ibitmap;
  258.     ushort idirty;        /* Set if ibitmap changed after last write */
  259.     long ilast;        /* search start for free inodes */
  260.     ushort *zbitmap;
  261.     ushort zdirty;        /* zbitmap dirty flag */
  262.     long zlast;        /* search start for free zones */
  263.  
  264. /* This lot is filled in as appropriate for each FS type */
  265.  
  266.     char version;        /* 0 for V1, 1 for V2 */
  267.     unsigned ipb;        /* Inodes per block */
  268.     unsigned zpind;        /* zones per indirection block */
  269.     unsigned dzpi;        /* direct zones per inode */
  270.     unsigned ndbl;        /* first zone number in double indirect block */
  271.     int increment;        /* num of dir_structs per dir entry */
  272.  
  273.     /* Mounting information */
  274.     long mnt_inode;        /* Inode this filesystem is mounted on or 0 */
  275.     long mnt_flags;        /* Various mount flags */
  276.     unsigned mnt_dev;    /* Device filesystem mounted on */
  277.  
  278. /* To aid searching for a mount point a linked list is maintained of filesystems
  279.  * mounted on this device. mnt_next points to the next filesystem mounted on the
  280.  * parent device; mnt_first is a pointer to the first filesystem mounted on
  281.  * *this* device. No, I'm not sure I understand that either :-)
  282.  */
  283.     struct __sinf *mnt_next;
  284.  
  285.     struct __sinf *mnt_first;
  286.  
  287. } super_info;
  288.  
  289. #define DFS ((super_info *) -1)
  290.  
  291. /* This is what a directory entry on the disk looks like. Note: we can use
  292.  * a dirty trick to use this same structure for large filenames > 14 chars
  293.  * the idea is to use only a fraction of the total entries , so that if
  294.  * say the filename size is 30 we just use entries 0,2,4,6,8 etc. d_name
  295.  * then occupies all of the next entry. This forces the max filename size
  296.  * to be 2 less than a power of two (and certainly less than 1022), normally
  297.  * 30 should be more than adequate to cover every filename you'll ever see.
  298.  * 62 is for paranoids, but remember the path name limit of 128 characters.
  299.  */
  300.  
  301. typedef struct {        /* directory entry */
  302.   unshort d_inum;        /* inode number */
  303.   char d_name[MMAX_FNAME(1)];    /* character string */
  304. } dir_struct;
  305.  
  306. typedef struct {        /* disk inode. */
  307.   unshort i_mode;        /* file type, protection, etc. */
  308.   unshort i_uid;        /* user id of the file's owner */
  309.   long i_size;            /* current file size in bytes */
  310.   long i_mtime;            /* when was file data last changed */
  311.   unchar i_gid;            /* group number */
  312.   unchar i_nlinks;        /* how many links to this file */
  313.   unshort i_zone[NR_ZONE_NUMS];    /* block nums for direct, ind, and dbl ind */
  314. } d_inode1;
  315.  
  316. typedef struct {        /* V2.x disk inode */
  317.   ushort i_mode;        /* file type, protection, etc. */
  318.   ushort i_nlinks;        /* how many links to this file. HACK! */
  319.   ushort i_uid;            /* user id of the file's owner. */
  320.   ushort i_gid;            /* group number HACK! */
  321.   long i_size;            /* current file size in bytes */
  322.   long i_atime;            /* when was file data last accessed */
  323.   long i_mtime;            /* when was file data last changed */
  324.   long i_ctime;            /* when was inode data last changed */
  325.   long i_zone[NR_ZONE_NUMS2];    /* block nums for direct, ind, and dbl ind */
  326. } d_inode;
  327.  
  328. typedef
  329.   union {
  330.     char bdata[BLOCK_SIZE];        /* ordinary user data */
  331.     dir_struct bdir[NR_DIR_ENTRIES];    /* directory block */
  332.     unshort bind1[NR_INDIRECTS];        /* indirect block */
  333.     long    bind[NR_INDIRECTS2];        /* v2 indirect block */
  334.     d_inode1 binode1[INODES_PER_BLOCK];    /* inode block */
  335.     d_inode binode[INODES_PER_BLOCK2]; /* v2 inode block */
  336.   } bufr;
  337.  
  338. typedef struct {
  339.     bufr    *buffer;
  340.     long     block;        /* Block number bufr contains */
  341.     short    drive;        /* Drive of bufr */
  342.     int    status;        
  343. /* Valid status values:
  344.  * 0=invalid
  345.  * 1=valid&clean 
  346.  * 2=dirty
  347.  * 3=dirty but not essential (i.e. don't complain if not written out)
  348.  */
  349.  
  350. } cache;
  351.  
  352. typedef struct {
  353.     cache *pos,*start,*end;
  354. } cache_control;
  355.  
  356. /* This is a special FILEPTR structure, it is pointed to by the devinfo field,
  357.  * this speeds up read and write. 
  358.  *    For write, 'zones' contains only the current writing block, which
  359.  * is used if lots of small writes take place. For reading it contains a list
  360.  * of the next few zones to read. Care is needed as an O_TRUNC (or a truncate
  361.  * which  nothing uses at  present) can invalidate all  of this.  lckfirst
  362.  * contains a pointer to where a pointer to the first lock is contained. This
  363.  * means that if the first lock is deleted then only *lckfirst need be altered.
  364.  * Following this is a series of 'guesses' as to where relevant info for a file
  365.  * may be contained. This means that most of the time functions can find the
  366.  * cache entry almost immediately, instead of searching. Since the cache is
  367.  * dynamic and entries can be overwritten, the guess is not perfect and is
  368.  * checked before use. If it is invalid then the guess is updated after a
  369.  * successful load or search.
  370.  */
  371.  
  372. typedef struct {
  373.     long    zones[PRE_READ];    /* Zonecache for pre-read,write */
  374.     long     fzone;            /* chunk number in zone[0] */
  375.     long    lzone;            /* Last valid chunk number */
  376.     LOCK     **lfirst;        /* pointer to pointer with first lock */
  377.     #define NOGUESS ( (cache **) 0) /* Don't guess cache entry */
  378.     cache     *iguess;        /* Guess at inode cache position */
  379.     cache    *zguess;        /* Guess at zone cache position */ 
  380.     cache    *izguess;        /* Ind zone guess */
  381.     cache    *dizguess;        /* Dbl ind zone guess */
  382. } f_cache;
  383.  
  384. /* Physical partition structure */
  385. struct phys_part {
  386. long start;        /* Physical partition start sector number */
  387. long finish;        /* End sector number */
  388. char shadow;        /* Rwabs dev number to access this drive at */
  389. char scsiz;        /* sector size 1=512 bytes 0=1K */
  390. };
  391.  
  392. /* Macros for indirection blocks */
  393.  
  394. #define PIND(vers,tmp,index) \
  395.     ( (vers) ? (tmp->bind[index]) : (tmp->bind1[index]) )
  396. #define IND(vers,temp,index) \
  397.     ( (vers) ? (temp.bind[index]) : (temp.bind1[index]) )
  398.  
  399. #endif
  400.